package com.jz.main.io.aio;

import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.AsynchronousFileChannel;
import java.nio.channels.CompletionHandler;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;

public class AioTest {
    public static void main(String[] args) {
        // 交换位置会产生不一样的效果
        aioAndSync();
        aio();

    }

    /**
     * 文件io
     * 业务线程会阻塞，非完全aio
     */
    static void aioAndSync(){
        System.out.println("===异步io 业务线程阻塞式===");
        Path filePath = Paths.get("D:/tmp/my.txt"); // 替换为你的文件路径
        int bufferSize = 1024; // 缓冲区大小

        try (AsynchronousFileChannel channel = AsynchronousFileChannel.open(filePath, StandardOpenOption.READ)) {
            ByteBuffer buffer = ByteBuffer.allocate(bufferSize);

            // 异步读取文件内容
            Future<Integer> result = channel.read(buffer, 0);

            // 添加一个CompletionHandler来处理读取完成后的操作
            result.get(); // 等待读取操作完成
            buffer.flip(); // 准备从缓冲区读取数据

            System.out.println("===异步io 业务线程阻塞式===io完成了");
            // 读取缓冲区中的数据
            while (buffer.hasRemaining()) {
                System.out.print((char) buffer.get());
            }
            System.out.println();
            System.out.println("===异步io 业务线程阻塞式===业务结束");
        } catch (IOException | InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
    }

    /**
     * 文件io
     * 业务线程非阻塞，完全aio
     */
    static void aio(){
        System.out.println("--------异步io 业务线程非阻塞式------业务开始");
        Path filePath = Paths.get("D:/tmp/my.txt"); // 替换为你的文件路径
        int bufferSize = 1024; // 缓冲区大小

        try (AsynchronousFileChannel channel = AsynchronousFileChannel.open(filePath, StandardOpenOption.READ)) {
            ByteBuffer buffer = ByteBuffer.allocate(bufferSize);

            // 异步读取文件内容，并指定一个CompletionHandler来处理读取完成后的操作
            channel.read(buffer, 0, buffer, new CompletionHandler<Integer, ByteBuffer>() {
                @Override
                public void completed(Integer result, ByteBuffer attachment) {
                    System.out.println("--------异步io 业务线程非阻塞式------io完成了");
                    // 读取操作完成，处理结果
                    attachment.flip(); // 准备从缓冲区读取数据
                    System.out.println();
                    while (attachment.hasRemaining()) {
                        System.out.print((char) attachment.get());
                    }
                    System.out.println();
                }

                @Override
                public void failed(Throwable exc, ByteBuffer attachment) {
                    // 读取操作失败，处理异常
                    exc.printStackTrace();
                }
            });

            System.out.println("--------异步io 业务线程非阻塞式------业务结束");
            // 等待读取操作完成（这里只是一个简单的示例，实际应用中可能需要更复杂的逻辑来处理异步操作）
//            Thread.sleep(1000); // 假设文件很小，1秒后应该读取完成
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

}
